﻿/**
 * clase que se ocupa de la persistencia de los objetos del juego
 * @author GRUPODOS
 *
 */
package Daos;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

import enums.TipoObjeto;
import excepciones.PersistenciaException;
import logica.acciones.Coordenada;
import logica.objetos.Barreminas;
import logica.objetos.Carguero;
import logica.objetos.Mina;
import logica.objetos.Minador;
import logica.objetos.Objeto;
import logica.objetos.Partida;

public class Objetos {

	/**
	 * Ingresa un objeto      * 
	 * @param o Objeto a ingresar con id de partida
	 * @return el id del objeto creado en la tabla objetos
	 * @throws PersistenciaException si ocurre error SQL
	 */

	public int ingresarObjeto(Connection t, Objeto o, int idPartida)
	throws PersistenciaException {
		int resu = 0;
		try {
			ConsultasSQL consultas = new ConsultasSQL();
			String query = consultas.insertarObjeto();
			PreparedStatement pstmt = t.prepareStatement(query, Statement.RETURN_GENERATED_KEYS);
			pstmt.setInt(1, 0);
			pstmt.setInt(2, o.getPosicionx());
			pstmt.setInt(3, o.getPosiciony());
			pstmt.setInt(4, o.getTipo().getValue());
			pstmt.setInt(5, o.getImagen());
			pstmt.setInt(6, idPartida);
			pstmt.executeUpdate();

			ResultSet rs = pstmt.getGeneratedKeys();
			if (rs.next()) {
				resu = rs.getInt(1);// retorna el id generado en la bd
				TipoObjeto tipo = o.getTipo();
				switch (tipo) {
				case BARCOCARGUERO:
					this.ingresarCarguero(t,(Carguero) o, resu);
					break;
				case BARCOMINADOR:
					this.ingresarMinador(t, (Minador) o, resu);
					break;
				case BARREMINAS:
					this.ingresarBarreminas(t, (Barreminas) o, resu);
					break;
				case MINASUBACUATICA:
					this.ingresarMina(t, (Mina) o, resu);
					break;
				case MINASUPERFICIE:
					this.ingresarMina(t, (Mina) o, resu);
					break;
				default:
					break;
				}
			}
			rs.close();
			pstmt.close();

		} catch (SQLException e) {
			throw new PersistenciaException(
					// "Ocurrio un error en el acceso a la BD al insertar");
					e.getMessage());
		}
		return resu;
	}

	/**
	 * busca un objeto por su identificador      * 
	 * @param idobjeto id Objeto a buscar
	 * @return el objeto cuyo identificador se ingreso. No contempla tipos derivados
	 * @throws PersistenciaException si ocurre error SQL
	 */
	private Objeto buscarObjetoAbstracto(Connection t, int idObjeto)
	throws PersistenciaException {
		Objeto resu = null;
		try {
			ConsultasSQL Consulta = new ConsultasSQL();
			String query = Consulta.buscarObjeto();
			PreparedStatement pstmt = t.prepareStatement(query);
			pstmt.setInt(1, idObjeto);
			ResultSet rs = pstmt.executeQuery();
			if (rs.next()) {
				int tipo = rs.getInt("tipo");
				//Obtengo el tipo de objeto
				TipoObjeto tipoObj = TipoObjeto.from(tipo);		
				resu = new Objeto(idObjeto, rs.getInt("posicionX"),
						rs.getInt("posicionY"), rs.getInt("idImagen"), tipoObj);
			}
			rs.close();
			pstmt.close();

		} catch (SQLException e) {
			throw new PersistenciaException(e.getMessage());
		}
		return resu;
	}

	/**
	 * busca un objeto  * 
	 * @param idobjeto id Objeto a buscar
	 * @return el objeto buscado con su tipo derivado
	 * @throws PersistenciaException si ocurre error SQL
	 */
	public Objeto buscarObjeto(Connection t, int idObjeto)
	throws PersistenciaException {
		Objeto resu = null;
		TipoObjeto tipoObj = this.buscarObjetoAbstracto(t, idObjeto).getTipo();
		switch (tipoObj) {
		case BARREMINAS:
			resu = this.buscarBarreminas(t, idObjeto);
			break;
		case BARCOCARGUERO:
			resu = this.buscarCarguero(t, idObjeto);
			break;
		case BARCOMINADOR:
			resu = this.buscarMinador(t, idObjeto);
			break;
		case MINASUBACUATICA:
			resu = this.buscarMina(t, idObjeto);
			break;
		case MINASUPERFICIE:
			resu = this.buscarMina(t, idObjeto);
			break;
		default:
			break;
		}
		return resu;
	}

	/**
	 * actualiza un objeto 
	 * @param o Objeto a actualizar
	 * @throws PersistenciaException si ocurre error SQL
	 */
	public void actualizarObjeto(Connection t, Objeto o) throws PersistenciaException {
		try {
			ConsultasSQL consulta = new ConsultasSQL();
			String query = consulta.modificarObjeto();	    
			PreparedStatement pstmt = t.prepareStatement(query);

			pstmt.setInt(1, o.getPosicionx());
			pstmt.setInt(2, o.getPosiciony());
			pstmt.setInt(3, o.getTipo().getValue());
			pstmt.setInt(4,o.getImagen());
			pstmt.setInt(5, o.getIdentificador());
			pstmt.executeUpdate();
			pstmt.close();

		} catch (SQLException e) {
			throw new PersistenciaException( e.getMessage());
			//"Error de persistencia");
		}
	}

	/**
	 * ingresa un barreminas y el id del objeto y retorna el id generado se <br>
	 * necesita que se ingrese primero el objeto para invocar este metodo * 
	 * @param b el barreminas
	 * @return el id del objeto creado en la tabla barcobarreminas
	 * @throws PersistenciaException
	 */
	private int ingresarBarreminas(Connection t, Barreminas b, int idObjeto)
	throws PersistenciaException {
		int resu = 0;
		try {
			ConsultasSQL consultas = new ConsultasSQL();
			String query = consultas.ingresarBarreminas();
			PreparedStatement pstmt = t.prepareStatement(query, Statement.RETURN_GENERATED_KEYS);
			pstmt.setInt(1, 0);
			pstmt.setInt(2, idObjeto);
			pstmt.setInt(3, b.getResistencia());
			pstmt.setInt(4, b.getDanio());
			pstmt.setInt(5, b.getAlcanceTiro());
			pstmt.setInt(6, b.getVisibilidad());
			pstmt.setInt(7, b.getVelocidad());
			pstmt.setInt(8, b.getAngulo());
			pstmt.setBoolean(9, b.isEsImpactado());
			pstmt.setInt(10, b.getMunicionesRestantes());
			pstmt.setInt(11, b.getRadioSonar());

			pstmt.executeUpdate();

			ResultSet rs = pstmt.getGeneratedKeys();
			if (rs.next())
				resu = rs.getInt(1);// retorna el id generado en la bd
			rs.close();
			pstmt.close();

		} catch (SQLException e) {
			throw new PersistenciaException(
					// "Ocurrio un error en el acceso a la BD al insertar");
					e.getMessage());
		}
		return resu;
	}

	/**
	 * actualiza un barreminas      * 
	 * @param b barreminas a actualizar 
	 * @throws PersistenciaException
	 */
	public void actualizarBarreminas(Connection t, Barreminas b) throws PersistenciaException {
		try {
			ConsultasSQL consulta = new ConsultasSQL();
			String query = consulta.modificarBarreminas();

			PreparedStatement pstmt = t.prepareStatement(query);	    
			pstmt.setInt(1, b.getResistencia());
			pstmt.setInt(2, b.getDanio());
			pstmt.setInt(3, b.getAlcanceTiro());
			pstmt.setInt(4, b.getVisibilidad());
			pstmt.setInt(5, b.getVelocidad());
			pstmt.setInt(6, b.getAngulo());
			pstmt.setBoolean(7, b.isEsImpactado());
			pstmt.setInt(8, b.getMunicionesRestantes());
			pstmt.setInt(9, b.getRadioSonar());
			pstmt.setInt(10,b.getIdentificador());

			pstmt.executeUpdate();
			pstmt.close();	    
			actualizarObjeto(t, b);

		} catch (SQLException e) {
			throw new PersistenciaException( e.getMessage());
			//"Error de persistencia");
		}
	}

	/**
	 * ingresa un minador y el id de objeto y retorna el id generado en la tabla <br>
	 * barcominador se necesita que se ingrese primero el objeto para invocar <br>
	 * este metodo 
	 * @param m el minador
	 * @return el id del minador recien generado
	 * @throws PersistenciaException
	 */
	private int ingresarMinador(Connection t, Minador m, int idObjeto)
	throws PersistenciaException {
		int resu = 0;
		try {
			ConsultasSQL consultas = new ConsultasSQL();

			String query = consultas.ingresarMinador();
			PreparedStatement pstmt = t.prepareStatement(query, Statement.RETURN_GENERATED_KEYS);
			pstmt.setInt(1, 0);
			pstmt.setInt(2, idObjeto);
			pstmt.setInt(3, m.getResistencia());
			pstmt.setInt(4, m.getDanio());
			pstmt.setInt(5, m.getAlcanceTiro());
			pstmt.setInt(6, m.getVisibilidad());
			pstmt.setInt(7, m.getVelocidad());
			pstmt.setInt(8, m.getAngulo());
			pstmt.setInt(9, 0);
			pstmt.setInt(10, m.getMunicionesRestantes());
			pstmt.setInt(11, m.getMinasRestantes());

			pstmt.executeUpdate();

			ResultSet rs = pstmt.getGeneratedKeys();
			if (rs.next())
				resu = rs.getInt(1);// retorno el id generado en la bd

			rs.close();
			pstmt.close();

		} catch (SQLException e) {
			throw new PersistenciaException(
					// "Ocurrio un error en el acceso a la BD al insertar");
					e.getMessage());
		}
		return resu;
	}
	/**
	 * actualiza un minador
	 * @param b barreminas a actualizar  
	 * @throws PersistenciaException
	 */
	public void actualizarMinador(Connection t, Minador m) throws PersistenciaException {
		try {
			ConsultasSQL consulta = new ConsultasSQL();
			String query = consulta.modificarMinador();

			PreparedStatement pstmt = t.prepareStatement(query);

			int esImpactado=0;
			if (m.isEsImpactado())
			{
				esImpactado=1;
			}	    
			pstmt.setInt(1, m.getResistencia());
			pstmt.setInt(2, m.getDanio());
			pstmt.setInt(3, m.getAlcanceTiro());
			pstmt.setInt(4, m.getVisibilidad());
			pstmt.setInt(5, m.getVelocidad());
			pstmt.setInt(6, m.getAngulo());
			pstmt.setInt(7, esImpactado);
			pstmt.setInt(8, m.getMunicionesRestantes());
			pstmt.setInt(9, m.getMinasRestantes());
			pstmt.setInt(10,m.getIdentificador());

			pstmt.executeUpdate();
			pstmt.close();

			actualizarObjeto(t, m);    
		} catch (SQLException e) {
			throw new PersistenciaException( e.getMessage());
			//"Error de persistencia");
		}
	}
	/**
	 * ingresa una mina y el id del objeto, y retorna el id generado en la
	 * tabla minas
	 * @param m la mina
	 * @return el id del objeto recien generado en la tabla minas
	 * @throws PersistenciaException si ocurre error SQL
	 */
	private int ingresarMina(Connection t, Mina m, int idObjeto)
	throws PersistenciaException {
		int resu = 0;
		try {
			ConsultasSQL consultas = new ConsultasSQL();
			String query = consultas.ingresarMina();
			PreparedStatement pstmt = t.prepareStatement(query, Statement.RETURN_GENERATED_KEYS);
			pstmt.setInt(1, 0);
			pstmt.setInt(2, idObjeto);
			pstmt.setInt(3, m.getTipoMina().getValue());
			pstmt.setInt(4, m.getRadioexplosion());
			pstmt.setInt(5, 0);

			pstmt.executeUpdate();

			ResultSet rs = pstmt.getGeneratedKeys();
			if (rs.next())
				resu = rs.getInt(1);// retorno el id generado en la bd

			rs.close();
			pstmt.close();

		} catch (SQLException e) {
			throw new PersistenciaException(
					"Ocurrio un error en el acceso a la BD al insertar");
		}
		return resu;
	}
	/**
	 * metodo que actualiza una mina
	 * @param t la transaccion
	 * @param m la mina a actualizar
	 * @throws PersistenciaException
	 */
	public void actualizarMina(Connection t, Mina m) throws PersistenciaException {
		try {
			ConsultasSQL consulta = new ConsultasSQL();
			String query = consulta.modificarMina();

			PreparedStatement pstmt = t.prepareStatement(query);	   
			pstmt.setInt(1, m.getTipo().getValue());
			pstmt.setInt(2, m.getRadioexplosion());
			pstmt.setBoolean(3, m.isEsExplotada());
			pstmt.setInt(4, m.getIdentificador());  

			pstmt.executeUpdate();
			pstmt.close();
			actualizarObjeto(t, m);

		} catch (SQLException e) {
			throw new PersistenciaException( e.getMessage());
			//"Error de persistencia");
		}
	}

	/**
	 * ingresa un carguero y retorna el id    * 
	 * @param c el carguero y el od del objeto
	 * @return el id recien geenrado en la tabla barcocarguero
	 * @throws PersistenciaException
	 *             si ocurre error SQL
	 */
	private int ingresarCarguero(Connection t, Carguero c, int idObjeto)
	throws PersistenciaException {
		int resu = 0;
		try {
			ConsultasSQL consultas = new ConsultasSQL();
			String query = consultas.ingresarCarguero();
			PreparedStatement pstmt = t.prepareStatement(query, Statement.RETURN_GENERATED_KEYS);
			pstmt.setInt(1, 0);// idBarcoCarguero`
			pstmt.setInt(2, idObjeto);// `idObjeto`
			pstmt.setInt(3, c.getResistencia());// `resistencia`
			pstmt.setInt(4, c.getDanio());// `danio`
			pstmt.setInt(5, c.getVisibilidad());// `visibilidad`
			pstmt.setInt(6, c.getVelocidad());// `velocidad`
			pstmt.setInt(7, c.getAngulo());// `angulo`
			pstmt.setInt(8, 0);// `esImpactado`
			pstmt.setInt(9, c.getDestinoX());
			pstmt.setInt(10, c.getDestinoY());

			pstmt.executeUpdate();

			ResultSet rs = pstmt.getGeneratedKeys();
			if (rs.next())
				resu = rs.getInt(1);// retorno el id generado en la bd

			rs.close();
			pstmt.close();

		} catch (SQLException e) {
			throw new PersistenciaException(
					// "Ocurrio un error en el acceso a la BD al insertar");
					e.getMessage());
		}

		return resu;
	}

	/**
	 * actualiza un carguero  * 
	 * @param t la transaccion
	 * @param c carguero a actualizar
	 * @throws PersistenciaException si ocurre error SQL
	 */
	public void actualizarCarguero(Connection t, Carguero c) throws PersistenciaException {
		try {
			ConsultasSQL consulta = new ConsultasSQL();
			String query = consulta.modificarCarguero();	    
			PreparedStatement pstmt = t.prepareStatement(query);

			pstmt.setInt(1, c.getResistencia());
			pstmt.setInt(2, c.getDanio());			
			pstmt.setInt(3, c.getVisibilidad());
			pstmt.setInt(4, c.getVelocidad());
			pstmt.setInt(5, c.getAngulo());
			pstmt.setBoolean(6, c.isEsImpactado());
			pstmt.setInt(7, c.getDestinoX());
			pstmt.setInt(8,c.getDestinoY());
			pstmt.setInt(9,c.getIdentificador());
			

			pstmt.executeUpdate();
			pstmt.close();

			actualizarObjeto(t, c);

		} catch (SQLException e) {
			throw new PersistenciaException( e.getMessage());
			//"Error de persistencia");
		}
	}
	/**
	 * retorna el barreminas dado el id de un objeto      * 
	 * @param idObjeto el id de la tabla objetos
	 * @return el barreminas si existe, null si no
	 * @throws PersistenciaException
	 *             si ocurre error SQL
	 */
	public Barreminas buscarBarreminas(Connection t, int idObjeto)
	throws PersistenciaException {
		Barreminas resu = null;
		try {
			ConsultasSQL Consulta = new ConsultasSQL();
			String query = Consulta.buscarBarreminas();
			PreparedStatement pstmt = t.prepareStatement(query);
			pstmt.setInt(1, idObjeto);

			ResultSet rs = pstmt.executeQuery();
			if (rs.next()) {

				Objeto o = buscarObjetoAbstracto(t, idObjeto);
				resu = new Barreminas(idObjeto, o.getPosicionx(),
						o.getPosiciony(), o.getImagen(), o.getTipo(),
						rs.getInt("resistencia"), rs.getInt("danio"),
						rs.getInt("alcanceTiro"), rs.getInt("visibilidad"),
						rs.getInt("velocidad"), rs.getInt("angulo"),
						rs.getBoolean("esImpactado"),
						rs.getInt("municionesRestantes"),
						rs.getInt("radioSonar"));
			}
			rs.close();
			pstmt.close();

		} catch (SQLException e) {
			throw new PersistenciaException(e.getMessage());
		}
		return resu;
	}

	/**
	 * retorna el minador dado el id de un objeto * 
	 * @param idObjeto   el id de la tabla objetos
	 * @return el minador si existe, null si no
	 * @throws PersistenciaException
	 *             si ocurre error SQL
	 */
	public Minador buscarMinador(Connection t, int idObjeto)
	throws PersistenciaException {
		Minador resu = null;
		try {
			ConsultasSQL Consulta = new ConsultasSQL();
			String query = Consulta.buscarMinador();
			PreparedStatement pstmt = t.prepareStatement(query);
			pstmt.setInt(1, idObjeto);

			ResultSet rs = pstmt.executeQuery();
			if (rs.next()) {

				Objeto o = buscarObjetoAbstracto(t, idObjeto);
				resu = new Minador(idObjeto, o.getPosicionx(),
						o.getPosiciony(), o.getImagen(), o.getTipo(),
						rs.getInt("resistencia"), rs.getInt("danio"),
						rs.getInt("alcanceTiro"), rs.getInt("visibilidad"),
						rs.getInt("velocidad"), rs.getInt("angulo"),
						rs.getBoolean("esImpactado"),
						rs.getInt("municionesRestantes"),
						rs.getInt("minasRestantes"));

			}
			rs.close();
			pstmt.close();

		} catch (SQLException e) {
			throw new PersistenciaException(e.getMessage());
		}
		return resu;

	}

	/**
	 * retorna el carguero dado el id de un objeto 
	 * @param idObjeto el id de la tabla objetos
	 * @return el carguero si existe, null si no
	 * @throws PersistenciaException
	 *             si ocurre error SQL
	 */
	public Carguero buscarCargueroPorIdPartida(Connection t, int idPartida)
	throws PersistenciaException {
		Carguero resu = null;
		try {
			ConsultasSQL Consulta = new ConsultasSQL();
			String query = Consulta.buscarCargueroPorIdPartida();
			PreparedStatement pstmt = t.prepareStatement(query);
			pstmt.setInt(1, idPartida);

			ResultSet rs = pstmt.executeQuery();
			if (rs.next()) {
				int idobjeto = rs.getInt(2);
				Objeto o = buscarObjetoAbstracto(t, idobjeto);
				resu = new Carguero(idobjeto, o.getPosicionx(),
						o.getPosiciony(), o.getImagen(), o.getTipo(),
						rs.getInt("resistencia"), rs.getInt("danio"), 0,
						rs.getInt("visibilidad"), rs.getInt("velocidad"),
						rs.getInt("angulo"), rs.getBoolean("esImpactado"), 
						rs.getInt("destinoX"), rs.getInt("destinoY"));
			}
			rs.close();
			pstmt.close();

		} catch (SQLException e) {
			throw new PersistenciaException(e.getMessage());
		}
		return resu;
	}
	
	public Carguero buscarCarguero(Connection t, int idObjeto)
	throws PersistenciaException {
		Carguero resu = null;
		try {
			ConsultasSQL Consulta = new ConsultasSQL();
			String query = Consulta.buscarCarguero();
			PreparedStatement pstmt = t.prepareStatement(query);
			pstmt.setInt(1, idObjeto);

			ResultSet rs = pstmt.executeQuery();
			if (rs.next()) {				
				Objeto o = buscarObjetoAbstracto(t, idObjeto);
				resu = new Carguero(idObjeto, o.getPosicionx(),
						o.getPosiciony(), o.getImagen(), o.getTipo(),
						rs.getInt("resistencia"), rs.getInt("danio"), 0,
						rs.getInt("visibilidad"), rs.getInt("velocidad"),
						rs.getInt("angulo"), rs.getBoolean("esImpactado"), 
						rs.getInt("destinoX"), rs.getInt("destinoY"));
			}
			rs.close();
			pstmt.close();

		} catch (SQLException e) {
			throw new PersistenciaException(e.getMessage());
		}
		return resu;
	}

	/**
	 * retorna la mina cuyo id de objeto es el ingresado
	 * @param idObjeto el id de la tabla objetos
	 * @return la mina si existe, null si no
	 * @throws PersistenciaException
	 *             si ocurre error SQL
	 */
	public Mina buscarMina(Connection t, int idObjeto)
	throws PersistenciaException {
		Mina resu = null;

		try {
			ConsultasSQL Consulta = new ConsultasSQL();
			String query = Consulta.buscarMina();
			PreparedStatement pstmt = t.prepareStatement(query);
			pstmt.setInt(1, idObjeto);

			ResultSet rs = pstmt.executeQuery();
			if (rs.next()) {
				Objeto o = buscarObjetoAbstracto(t, idObjeto);
				int tipo = rs.getInt("tipo");
				//Obtengo el tipo de objeto
				TipoObjeto tipoObj = TipoObjeto.from(tipo);

				resu = new Mina(idObjeto, o.getPosicionx(), o.getPosiciony(),
						o.getImagen(), o.getTipo(),tipoObj,
						rs.getInt("radioExplosion"),
						rs.getBoolean("esExplotada"));
			}
			rs.close();
			pstmt.close();

		} catch (SQLException e) {
			throw new PersistenciaException(e.getMessage());
		}
		return resu;
	}

	/**
	 * lista todos los objetos de una partida. Cada objeto segun su tipo
	 * (carguero, barreminas, etc) * 
	 * @param t
	 *            la transaccion
	 * @param idPartida
	 *            el id de la partida buscada
	 * @return un array de todos los objetos de la partida
	 * @throws PersistenciaException
	 *             si ocurre error SQL
	 */
	public Objeto[] buscarTodosLosObjetosDePartida(Connection t, int idPartida)
	throws PersistenciaException {
		Objeto[] resu = null;
		try {
			ConsultasSQL Consulta = new ConsultasSQL();
			String query = Consulta.buscarObjetosPorIdPartida();
			PreparedStatement pstmt = t.prepareStatement(query);
			pstmt.setInt(1, idPartida);// cambia del orden de las sentencias
			ResultSet rs = pstmt.executeQuery();
			// cambia la forma de tomar el tamanio del resultset
			rs.last(); // al último
			int cantidad = rs.getRow(); // el tamaño
			rs.beforeFirst();// vuelve al principio
			resu = new Objeto[cantidad];
			int i = 0;
			while (rs.next()) {

				int idObjeto = rs.getInt(1);
				Objeto o = this.buscarObjeto(t, idObjeto);// trae el objeto
				// entero
				if (i < cantidad) {
					resu[i] = o;
					i++;
				}
			}
			rs.close();
			pstmt.close();

		} catch (SQLException e) {
			throw new PersistenciaException(e.getMessage());
		}
		return resu;
	}

	/**
	 * Busca el objeto por la poscicion
	 * @param t la transaccion 
	 * @param pos las coordenadas
	 * @param idPartida el id de la partida
	 * @return el objeto en esa posicion 
	 * @throws PersistenciaException si ocurre error SQL
	 */
	public Objeto buscarObjetoPorPosicion(Connection t, Coordenada pos, String idPartida) 
	throws PersistenciaException
	{
		Objeto obj=null;
		try{

			ConsultasSQL consultas = new ConsultasSQL();
			String query = consultas.buscarObjetoPorPosicion();
			PreparedStatement pstmt = t.prepareStatement(query);
			pstmt.setInt(1, pos.getX());
			pstmt.setInt(2, pos.getY());
			pstmt.setString(3, idPartida);

			ResultSet rs = pstmt.executeQuery();
			if (rs.next()){
				int idObjeto=rs.getInt(1);	    	
				obj=this.buscarObjeto(t, idObjeto);
			}
			rs.close();
			pstmt.close();
		}
		catch (SQLException e) {
			throw new PersistenciaException(e.getMessage());
		}
		return obj;
	}

	/**
	 * Elimina la mina subacuatica por idObjeto
	 * @param t la transaccion
	 * @param idObjeto el identificador del obejto
	 * @throws PersistenciaException
	 */

	public void eliminarMinaSubAcuatica(Connection t,int idObjeto) throws PersistenciaException {

		ConsultasSQL consulta = new ConsultasSQL();
		String query = consulta.eliminarMinaSubAcuatica();
		try {
			PreparedStatement pstm = t.prepareStatement(query);
			pstm.setInt(1, idObjeto);
			pstm.executeUpdate();
			pstm.close();
			//Elimino el objeto asociado
			eliminarObjeto(t, idObjeto);
		} catch (SQLException e) {
			throw new PersistenciaException("Error al eliminar Mina");
		}	
	}

	/*** Elimina la mina superficial por idObjeto
	 * @param t la transaccion
	 * @param idObjeto el identificador del objeto
	 * @throws PersistenciaException si ocurre error SQL
	 */
	public void eliminarMinaSuperficial(Connection t,int idObjeto) throws PersistenciaException {

		ConsultasSQL consulta = new ConsultasSQL();
		String query = consulta.eliminarMinaSuperficial();
		try {
			PreparedStatement pstm = t.prepareStatement(query);
			pstm.setInt(1, idObjeto);
			pstm.executeUpdate();
			pstm.close();
			//Elimino el objeto asociado
			eliminarObjeto(t, idObjeto);
		} catch (SQLException e) {
			throw new PersistenciaException("Error al eliminar Mina");
		}

	}
	/**
	 * elimina el objeto con el identificador ingresado.
	 * <br> solo lo elimina de la tabla objetos
	 * @param t la transaccion
	 * @param idObjeto el identificador del obejto
	 * @throws PersistenciaException si ocurre error SQL
	 */
	public void eliminarObjeto(Connection t,int idObjeto) throws PersistenciaException {

		ConsultasSQL consulta = new ConsultasSQL();
		String query = consulta.eliminarObjeto();
		try {
			PreparedStatement pstm = t.prepareStatement(query);
			pstm.setInt(1, idObjeto);
			pstm.executeUpdate();
			pstm.close();
		} catch (SQLException e) {
			throw new PersistenciaException("Error al eliminar Mina");
		}

	}
	/**
	 * dado un tipo de barco y una partida, buscar el objeto relacionado a el
	 * @param t la transaccion
	 * @param partida la partida
	 * @param barco el tipo de barco
	 * @return el objeto entero
	 * @throws PersistenciaException si ocurre error SQL
	 */
	public Objeto buscarBarcoEnPartida(Connection t, Partida partida,
			TipoObjeto barco) throws PersistenciaException{
		// TODO Auto-generated method stub
		Objeto resu = null;
		String sql = ConsultasSQL.buscarBarcoEnPartida();
		try {
			PreparedStatement ps = t.prepareStatement(sql);
			ps.setInt(1,partida.getIdentificador());
			ps.setInt(2, barco.getValue());
			ResultSet rs = ps.executeQuery();
			if(rs.next())
			{
				int idBarco = rs.getInt(1);
				resu = this.buscarObjeto(t, idBarco);
			}

			rs.close();
			ps.close();
		} catch (SQLException e) {
			throw new PersistenciaException("Error al eliminar Mina");
		}		
		return resu;
	}

}